// VideoTypeController.js - 视频类型控制器
const VideoType = require('../models/VideoType');

class VideoTypeController {
  /**
   * 获取所有视频类型（公开接口，无需认证）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async getAllTypes(req, res) {
    try {
      const types = await VideoType.getAll();
      res.status(200).json({
        code: 200,
        message: '获取视频类型列表成功',
        data: types
      });
    } catch (error) {
      console.error('获取视频类型列表失败:', error);
      res.status(500).json({
        code: 500,
        message: '获取视频类型列表失败',
        error: error.message
      });
    }
  }

  /**
   * 根据ID获取视频类型（公开接口，无需认证）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async getTypeById(req, res) {
    try {
      const { id } = req.params;
      
      // 验证参数
      if (!id || isNaN(parseInt(id, 10))) {
        return res.status(400).json({
          code: 400,
          message: '视频类型ID无效'
        });
      }
      
      const typeId = parseInt(id, 10);
      const type = await VideoType.getById(typeId);
      
      if (!type) {
        return res.status(404).json({
          code: 404,
          message: '视频类型不存在'
        });
      }
      
      res.status(200).json({
        code: 200,
        message: '获取视频类型成功',
        data: type
      });
    } catch (error) {
      console.error('获取视频类型失败:', error);
      res.status(500).json({
        code: 500,
        message: '获取视频类型失败',
        error: error.message
      });
    }
  }

  /**
   * 创建新视频类型（管理员接口，需认证）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async createType(req, res) {
    try {
      const { name, description } = req.body;
      
      // 参数验证
      if (!name) {
        return res.status(400).json({
          code: 400,
          message: '视频类型名称不能为空'
        });
      }
      
      // 检查名称是否已存在
      const exists = await VideoType.exists(name);
      if (exists) {
        return res.status(400).json({
          code: 400,
          message: '视频类型名称已存在'
        });
      }
      
      // 创建视频类型
      const newType = await VideoType.create(name, description || '');
      
      res.status(201).json({
        code: 201,
        message: '创建视频类型成功',
        data: newType
      });
    } catch (error) {
      console.error('创建视频类型失败:', error);
      
      // 处理唯一键冲突
      if (error.code === 'ER_DUP_ENTRY' || error.code === 'ER_DUP_UNIQUE') {
        return res.status(400).json({
          code: 400,
          message: '视频类型名称已存在'
        });
      }
      
      res.status(500).json({
        code: 500,
        message: '创建视频类型失败',
        error: error.message
      });
    }
  }

  /**
   * 更新视频类型（管理员接口，需认证）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async updateType(req, res) {
    try {
      const { id } = req.params;
      const updateData = req.body;
      
      // 验证参数
      if (!id || isNaN(parseInt(id, 10))) {
        return res.status(400).json({
          code: 400,
          message: '视频类型ID无效'
        });
      }
      
      const typeId = parseInt(id, 10);
      
      // 验证视频类型是否存在
      const existingType = await VideoType.getById(typeId);
      if (!existingType) {
        return res.status(404).json({
          code: 404,
          message: '视频类型不存在'
        });
      }
      
      // 如果更新名称，检查是否与其他类型重复
      if (updateData.name !== undefined && updateData.name !== existingType.name) {
        const exists = await VideoType.exists(updateData.name, typeId);
        if (exists) {
          return res.status(400).json({
            code: 400,
            message: '视频类型名称已存在'
          });
        }
      }
      
      // 更新视频类型
      const updatedType = await VideoType.update(typeId, updateData);
      
      res.status(200).json({
        code: 200,
        message: '更新视频类型成功',
        data: updatedType
      });
    } catch (error) {
      console.error('更新视频类型失败:', error);
      
      // 处理唯一键冲突
      if (error.code === 'ER_DUP_ENTRY' || error.code === 'ER_DUP_UNIQUE') {
        return res.status(400).json({
          code: 400,
          message: '视频类型名称已存在'
        });
      }
      
      res.status(500).json({
        code: 500,
        message: '更新视频类型失败',
        error: error.message
      });
    }
  }

  /**
   * 删除视频类型（管理员接口，需认证）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async deleteType(req, res) {
    try {
      const { id } = req.params;
      
      // 验证参数
      if (!id || isNaN(parseInt(id, 10))) {
        return res.status(400).json({
          code: 400,
          message: '视频类型ID无效'
        });
      }
      
      const typeId = parseInt(id, 10);
      
      // 验证视频类型是否存在
      const existingType = await VideoType.getById(typeId);
      if (!existingType) {
        return res.status(404).json({
          code: 404,
          message: '视频类型不存在'
        });
      }
      
      // 直接在控制器中执行删除，不通过模型的delete方法
      const { sequelize } = require('../config/db');
      const query = 'DELETE FROM video_type WHERE type_id = ?';
      await sequelize.query(query, {
        replacements: [typeId],
        raw: true
      });
      
      // 验证删除是否成功
      const stillExists = await VideoType.getById(typeId);
      if (stillExists) {
        return res.status(500).json({
          code: 500,
          message: '删除视频类型失败'
        });
      }
      
      res.status(200).json({
        code: 200,
        message: '删除视频类型成功'
      });
    } catch (error) {
      console.error('删除视频类型失败:', error);
      
      // 处理外键约束错误
      if (error.code === 'ER_ROW_IS_REFERENCED_2' || error.code === 'ER_NO_REFERENCED_ROW_2') {
        return res.status(400).json({
          code: 400,
          message: '该视频类型下存在关联数据，无法删除'
        });
      }
      
      res.status(500).json({
        code: 500,
        message: '删除视频类型失败',
        error: error.message
      });
    }
  }
}

module.exports = VideoTypeController;